package com.seu.vcampus.srv;

import com.seu.vcampus.dao.UserDao;
import com.seu.vcampus.message.Message;
import com.seu.vcampus.vo.User;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.sql.Connection;
import java.util.List;
import java.util.UUID;

/**
 * 用户管理服务类
 * 处理用户相关的业务逻辑
 * 
 * @author 虚拟校园开发团队
 * @since 1.0.0
 */
public class UserService {
    private static final Logger logger = LoggerFactory.getLogger(UserService.class);
    private final UserDao userDao;
    
    public UserService(Connection connection) {
        this.userDao = new UserDao(connection);
    }
    
    /**
     * 用户登录
     * @param message 登录请求消息
     * @return 登录响应消息
     */
    public Message login(Message message) {
        try {
            User loginUser = (User) message.getPayload();
            String username = loginUser.getUsername();
            String password = loginUser.getPassword();
            
            logger.info("用户登录请求: {}", username);
            
            User user = userDao.findByUsername(username);
            if (user == null) {
                return Message.error("用户不存在");
            }
            
            if (!user.getPassword().equals(password)) {
                return Message.error("密码错误");
            }
            
            if (!user.isActive()) {
                return Message.error("账户已被禁用");
            }
            
            // 更新最后登录时间
            userDao.updateLastLogin(user.getUserId());
            
            // 创建会话ID
            String sessionId = UUID.randomUUID().toString();
            
            logger.info("用户登录成功: {}", username);
            
            Message response = Message.success(Message.Type.LOGIN_RESPONSE, user);
            response.setSessionId(sessionId);
            return response;
            
        } catch (Exception e) {
            logger.error("用户登录失败", e);
            return Message.error("登录失败: " + e.getMessage());
        }
    }
    
    /**
     * 用户注册
     * @param message 注册请求消息
     * @return 注册响应消息
     */
    public Message register(Message message) {
        try {
            User newUser = (User) message.getPayload();
            
            logger.info("用户注册请求: {}", newUser.getUsername());
            
            // 检查用户名是否已存在
            if (userDao.findByUsername(newUser.getUsername()) != null) {
                return Message.error("用户名已存在");
            }
            
            // 验证用户类型，只允许学生和教师通过注册接口注册
            if (newUser.getUserType() != User.UserType.STUDENT && newUser.getUserType() != User.UserType.TEACHER) {
                return Message.error("不允许注册该类型的用户");
            }
            
            // 生成用户ID
            String userId = generateUserId(newUser.getUserType());
            newUser.setUserId(userId);
            
            // 保存用户
            boolean saved = userDao.save(newUser);
            if (!saved) {
                return Message.error("注册失败");
            }
            
            logger.info("用户注册成功: {}", newUser.getUsername());
            
            return Message.success(Message.Type.REGISTER_RESPONSE, newUser);
            
        } catch (Exception e) {
            logger.error("用户注册失败", e);
            return Message.error("注册失败: " + e.getMessage());
        }
    }
    
    /**
     * 用户注销
     * @param message 注销请求消息
     * @return 注销响应消息
     */
    public Message logout(Message message) {
        try {
            String userId = (String) message.getPayload();
            logger.info("用户注销请求: {}", userId);
            
            // 在实际应用中，这里可以清理会话信息
            
            return Message.success(Message.Type.LOGOUT_RESPONSE, "注销成功");
            
        } catch (Exception e) {
            logger.error("用户注销失败", e);
            return Message.error("注销失败: " + e.getMessage());
        }
    }
    
    /**
     * 获取用户信息
     * @param message 获取用户请求消息
     * @return 用户响应消息
     */
    public Message getUser(Message message) {
        try {
            String userId = (String) message.getPayload();
            
            logger.info("获取用户信息请求: {}", userId);
            
            User user = userDao.findById(userId);
            if (user == null) {
                return Message.error("用户不存在");
            }
            
            return Message.success(Message.Type.GET_USER_RESPONSE, user);
            
        } catch (Exception e) {
            logger.error("获取用户信息失败", e);
            return Message.error("获取用户信息失败: " + e.getMessage());
        }
    }
    
    /**
     * 更新用户信息
     * @param message 更新用户请求消息
     * @return 更新响应消息
     */
    public Message updateUser(Message message) {
        try {
            User user = (User) message.getPayload();
            
            logger.info("更新用户信息请求: {}", user.getUserId());
            
            boolean updated = userDao.save(user);
            if (!updated) {
                return Message.error("更新失败");
            }
            
            return Message.success(Message.Type.UPDATE_USER_RESPONSE, user);
            
        } catch (Exception e) {
            logger.error("更新用户信息失败", e);
            return Message.error("更新失败: " + e.getMessage());
        }
    }
    
    /**
     * 删除用户
     * @param message 删除用户请求消息
     * @return 删除响应消息
     */
    public Message deleteUser(Message message) {
        try {
            String userId = (String) message.getPayload();
            
            logger.info("删除用户请求: {}", userId);
            
            boolean deleted = userDao.delete(userId);
            if (!deleted) {
                return Message.error("删除失败");
            }
            
            return Message.success(Message.Type.DELETE_USER_RESPONSE, "删除成功");
            
        } catch (Exception e) {
            logger.error("删除用户失败", e);
            return Message.error("删除失败: " + e.getMessage());
        }
    }
    
    /**
     * 获取所有用户
     * @param message 获取所有用户请求消息
     * @return 用户列表响应消息
     */
    public Message getAllUsers(Message message) {
        try {
            logger.info("获取所有用户请求");
            
            List<User> users = userDao.findAll();
            
            return Message.success(Message.Type.GET_USER_RESPONSE, users);
            
        } catch (Exception e) {
            logger.error("获取所有用户失败", e);
            return Message.error("获取所有用户失败: " + e.getMessage());
        }
    }
    
    /**
     * 搜索用户
     * @param message 搜索用户请求消息，payload包含搜索参数数组[keyword, type, status]
     * @return 用户列表响应消息
     */
    public Message searchUsers(Message message) {
        try {
            Object[] searchParams = (Object[]) message.getPayload();
            String keyword = (String) searchParams[0];
            String type = (String) searchParams[1];
            String status = (String) searchParams[2];
            
            logger.info("搜索用户请求: keyword={}, type={}, status={}", keyword, type, status);
            
            // 转换用户类型
            User.UserType userType = null;
            if (!"全部类型".equals(type)) {
                userType = com.seu.vcampus.util.UserTypeConverter.fromDisplayText(type);
            }
            
            // 转换状态
            Boolean active = null;
            if (!"全部状态".equals(status)) {
                active = "启用".equals(status);
            }
            
            // 如果keyword为空字符串，转为null
            if (keyword != null && keyword.trim().isEmpty()) {
                keyword = null;
            }
            
            List<User> users = userDao.searchUsers(keyword, userType, active);
            
            return Message.success(Message.Type.GET_USER_RESPONSE, users);
            
        } catch (Exception e) {
            logger.error("搜索用户失败", e);
            return Message.error("搜索用户失败: " + e.getMessage());
        }
    }
    
    /**
     * 生成用户ID
     * @param userType 用户类型
     * @return 生成的用户ID
     */
    private String generateUserId(User.UserType userType) {
        String prefix;
        switch (userType) {
            case STUDENT:
                prefix = "S";
                break;
            case TEACHER:
                prefix = "T";
                break;
            case ADMIN:
                prefix = "A";
                break;
            default:
                prefix = "U";
                break;
        }
        return prefix + System.currentTimeMillis();
    }
    
    /**
     * 获取用户权限
     * @param userId 用户ID
     * @return 权限列表
     */
    public List<String> getUserPermissions(String userId) {
        return userDao.getUserPermissions(userId);
    }
    
    /**
     * 检查用户权限
     * @param userId 用户ID
     * @param permission 权限名称
     * @return 是否拥有权限
     */
    public boolean hasPermission(String userId, String permission) {
        return userDao.hasPermission(userId, permission);
    }
    
    /**
     * 为用户添加权限
     * @param userId 用户ID
     * @param permission 权限名称
     * @return 是否添加成功
     */
    public boolean addPermission(String userId, String permission) {
        return userDao.addPermission(userId, permission);
    }
    
    /**
     * 删除用户权限
     * @param userId 用户ID
     * @param permission 权限名称
     * @return 是否删除成功
     */
    public boolean removePermission(String userId, String permission) {
        return userDao.removePermission(userId, permission);
    }
}